/**
 *  Copyright [2022] [https://www.xiaonuo.vip]
 *	Snowy采用APACHE LICENSE 2.0开源协议，您在使用过程中，需要注意以下几点：
 *	1.请不要删除和修改根目录下的LICENSE文件。
 *	2.请不要删除和修改Snowy源码头部的版权声明。
 *	3.本项目代码可免费商业使用，商业使用请保留源码和相关描述文件的项目出处，作者声明等。
 *	4.分发源码时候，请注明软件出处 https://www.xiaonuo.vip
 *	5.不可二次分发开源参与同类竞品，如有想法可联系团队xiaonuobase@qq.com商议合作。
 *	6.若您的项目无法满足以上几点，需要更多功能代码，获取Snowy商业授权许可，请在官网购买授权，地址为 https://www.xiaonuo.vip
 */
/*
 * @Descripttion: 工具集
 * @version: 1.1
 * @LastEditors: yubaoshan
 * @LastEditTime: 2022年4月19日10:58:41
 */
const tool = {}
import dayjs from 'dayjs'

// localStorage
tool.data = {
	set(table, settings) {
		const _set = JSON.stringify(settings)
		return localStorage.setItem(table, _set)
	},
	get(table) {
		let data = localStorage.getItem(table)
		try {
			data = JSON.parse(data)
		} catch (err) {
			return null
		}
		return data
	},
	remove(table) {
		return localStorage.removeItem(table)
	},

	clear() {
		return localStorage.clear()
	}
}

// sessionStorage
tool.session = {
	set(table, settings) {
		const _set = JSON.stringify(settings)
		return sessionStorage.setItem(table, _set)
	},
	get(table) {
		let data = sessionStorage.getItem(table)
		try {
			data = JSON.parse(data)
		} catch (err) {
			return null
		}
		return data
	},
	remove(table) {
		return sessionStorage.removeItem(table)
	},
	clear() {
		return sessionStorage.clear()
	}
}

// 千分符
tool.groupSeparator = (num) => {
	num = `${num}`
	if (!num.includes('.')) num += '.'

	return num
		.replace(/(\d)(?=(\d{3})+\.)/g, ($0, $1) => {
			return `${$1},`
		})
		.replace(/\.$/, '')
}

// 获取所有字典数组
tool.dictDataAll = () => {
	return tool.data.get('DICT_TYPE_TREE_DATA')
}

// 转换时间格式
tool.changDate = (date) => {
	if (date) {
		return dayjs(new Date(date)).format('YYYY-M-D')
	} else {
		return ''
	}
}

// 转换时间格式
tool.changDates = (date) => {
	if (date) {
		return dayjs(new Date(date)).format('YYYY-MM')
	} else {
		return ''
	}
}

// 获取对应审批流程
tool.selectModel = (value) => {
	let models = tool.data.get('MODELLIST')
	let target = models.find((item) => item.name == value)
	if (target) {
		return target
	} else {
		return false
	}
}

// 判断是否存在该流程
tool.isProcess = (value) => {
	let models = tool.data.get('MODELLIST')
	let target = models.some((item) => item.name === value)
	return target
	
}

// 字典翻译方法，界面插槽使用方法 {{ $TOOL.dictType('sex', record.sex) }}
tool.dictTypeData = (dictValue, value) => {
	const dictTypeTree = tool.dictDataAll()
	if (!dictTypeTree) {
		return '需重新登录'
	}
	const tree = dictTypeTree.find((item) => item.dictValue == dictValue)
	if (!tree) {
		return value
	}
	const children = tree.children
	const dict = children.find((item) => item.dictValue == value)
	return dict ? dict.dictLabel : value
}

// 获取某个code下字典的列表，多用于字典下拉框
tool.dictTypeList = (dictValue) => {
	const dictTypeTree = tool.dictDataAll()
	if (!dictTypeTree) {
		return []
	}
	const tree = dictTypeTree.find((item) => item.dictValue === dictValue)
	if (tree && tree.children) {
		return tree.children
	}
	return []
}

// 获取某个code下字典的列表，基于dictTypeList 改进，保留老的，逐步替换
tool.dictList = (dictValue) => {
	const dictTypeTree = tool.dictDataAll()
	if (!dictTypeTree) {
		return []
	}
	const tree = dictTypeTree.find((item) => item.dictValue === dictValue)
	if (tree?.children) {
		return tree.children.map((item) => {
			return {
				value: item['dictValue'],
				label: item['name']
			}
		})
	}
	return []
}

// 树形翻译 需要指定最顶级的 parentValue  和当级的value
tool.translateTree = (parentValue, value) => {
	const tree = tool.dictDataAll().find((item) => item.dictValue === parentValue)
	const targetNode = findNodeByValue(tree, value)
	return targetNode ? targetNode.dictLabel : ''
}
const findNodeByValue = (node, value) => {
	if (node.dictValue === value) {
		return node
	}
	if (node.children) {
		for (let i = 0; i < node.children.length; i++) {
			const result = findNodeByValue(node.children[i], value)
			if (result) {
				return result
			}
		}
	}
	return null
}

// 生成UUID
tool.snowyUuid = () => {
	let uuid = 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
		let r = (Math.random() * 16) | 0,
			v = c === 'x' ? r : (r & 0x3) | 0x8
		return v.toString(16)
	})
	// 首字符转换成字母
	return 'xn' + uuid.slice(2)
}

// 判断是否为JSON数组
tool.isJsonArray = (str) => {
	try {
		var obj = JSON.parse(str)
		return Array.isArray(obj)
	} catch (e) {
		// 解析出错，不是有效的JSON数组
		return false
	}
}

// 判断是否显示预览按钮
tool.isPreviewDisplay = (record) => {
	if (!record.fileName && !record.file) {
		return false
	}
	// let name = record.fileName || record.file;
	// const suffix = name.toLowerCase().split('.').pop();
	return true
	// if (
	// 	suffix === 'doc' ||
	// 	suffix === 'txt' ||
	// 	suffix === 'docx' ||
	// 	suffix === 'xls' ||
	// 	suffix === 'xlsx' ||
	// 	suffix === 'pdf' ||
	// 	suffix === 'jpg' ||
	// 	suffix === 'png' ||
	// 	suffix === 'gif' ||
	// 	suffix === 'svg' ||
	// 	suffix === 'ico' ||
	// 	suffix === 'tmp' ||
	// 	suffix === 'zip' ||
	// 	suffix === 'jpeg'
	// ) {
	// 	return true
	// }
}

// 文件大小转换
tool.bytesToSize = (size) => {
	if (!size) return ''
	if (size < 0.1 * 1024) {
		//小于0.1KB，则转化成B
		size = size.toFixed(2) + 'B'
	} else if (size < 0.1 * 1024 * 1024) {
		// 小于0.1MB，则转化成KB
		size = (size / 1024).toFixed(2) + 'KB'
	} else if (size < 0.1 * 1024 * 1024 * 1024) {
		// 小于0.1GB，则转化成MB
		size = (size / (1024 * 1024)).toFixed(2) + 'MB'
	} else {
		// 其他转化成GB
		size = (size / (1024 * 1024 * 1024)).toFixed(2) + 'GB'
	}

	// 转成字符串
	let sizeStr = size + '',
		// 获取小数点处的索引
		index = sizeStr.indexOf('.'),
		// 获取小数点后两位的值
		dou = sizeStr.substr(index + 1, 2)

	// 判断后两位是否为00，如果是则删除00
	if (dou == '00') return sizeStr.substring(0, index) + sizeStr.substr(index + 3, 2)

	return size
}

// 数据转换成人民币大写
tool.numberToChinese = (num) => {
	const units = ['', '拾', '佰', '仟', '万', '拾万', '佰万', '仟万', '亿']
	const digits = ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖']

	if (num === 0) return '零整'

	// 处理小数，使用toFixed(2)确保两位小数
	const numStr = parseFloat(num).toFixed(2)
	const parts = numStr.split('.')
	const integerPart = parseInt(parts[0])
	const decimalPart = parts[1]

	let result = ''
	let unitIndex = 0
	let tempNum = integerPart

	// 处理整数部分
	if (integerPart === 0) {
		result = '零'
	} else {
		while (tempNum > 0) {
			const digit = tempNum % 10
			if (digit !== 0) {
				result = digits[digit] + units[unitIndex] + result
			} else if (result.charAt(0) !== digits[0]) {
				result = digits[0] + result
			}
			tempNum = Math.floor(tempNum / 10)
			unitIndex++
		}
	}

	result = result.replace(/零+/g, '零').replace(/零$/, '')

	// 处理小数部分
	if (decimalPart) {
		const jiao = parseInt(decimalPart[0])
		const fen = parseInt(decimalPart[1])

		if (jiao === 0 && fen === 0) {
			result += '元整'
		} else {
			if (jiao !== 0) {
				result += digits[jiao] + '角'
			}
			if (fen !== 0) {
				result += digits[fen] + '分'
			}
			result += '整'
		}
	} else {
		result += '整'
	}

	return result
}

/**
 * 安全转换JSON字符串为数组
 * @param {string} jsonString - 要转换的JSON字符串
 * @param {Array} defaultValue - 转换失败时返回的默认值
 * @returns {Array} 转换后的数组或默认值
 */
tool.safeParseJSON = (jsonString, defaultValue = []) => {
	if (!jsonString) {
		return defaultValue
	}

	try {
		const parsed = JSON.parse(jsonString)
		return Array.isArray(parsed) ? parsed : defaultValue
	} catch (error) {
		console.warn('JSON parse error:', error)
		return defaultValue
	}
}

tool.checkProperty = (obj, prop) => {
	// 检查对象是否有该属性，并且该属性的值不是数组
	if (obj.hasOwnProperty(prop) && !Array.isArray(obj[prop])) {
		return obj[prop].isedit // 属性存在且值不是数组
	} else {
		return false // 属性不存在或值是数组
	}
}

/**
 * 对比两个JSON字符串，并且标记isedit
 * @param {string} oldJson - 要转换的JSON字符串
 * @param {string} newJson - 转换失败时返回的默认值
 * @returns {Array} 转换后的数组
 */
tool.markJsonChanges = (oldJson, newJson) => {
	for (const key in newJson) {
		if (!oldJson.hasOwnProperty(key)) {
			newJson[key] = { value: newJson[key], isedit: true }
		} else if (Array.isArray(newJson[key]) && Array.isArray(oldJson[key])) {
			// 处理数组类型
			newJson[key] = newJson[key].map((item, index) => {
				if (index < oldJson[key].length) {
					return tool.markJsonChanges(oldJson[key][index], item)
				} else {
					return tool.markJsonChanges({}, item)
				}
			})
		} else if (
			typeof newJson[key] === 'object' &&
			newJson[key] !== null &&
			typeof oldJson[key] === 'object' &&
			oldJson[key] !== null
		) {
			tool.markJsonChanges(oldJson[key], newJson[key])
		} else if (newJson[key] !== oldJson[key]) {
			newJson[key] = { value: newJson[key], isedit: true }
		} else {
			newJson[key] = { value: newJson[key], isedit: false }
		}
	}
	return newJson
}

/**
 * 将数组转换为字符串
 * @param {Array} array - 要转换的数组
 * @param {string} separator - 分隔符，默认为逗号
 * @returns {string} 转换后的字符串
 */
tool.arrayToString = (array, separator = ',') => {
	if (!Array.isArray(array)) {
		return ''
	}
	return array.join(separator)
}

/**
 * 将字符串转换为数组
 * @param {string} str - 要转换的字符串
 * @param {string} separator - 分隔符，默认为逗号
 * @returns {Array} 转换后的数组
 */
tool.stringToArray = (str, separator = ',') => {
	if (typeof str !== 'string') {
		return []
	}
	return str.split(separator).filter((item) => item.trim() !== '')
}

export default tool
